package a.i;

import a.c.d;
import a.c.e;
import a.c.k;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class l
{
  public static int a;
  
  public static Comparator a(k paramk)
  {
    return new b_(paramk);
  }
  
  public static Comparator b(k paramk)
  {
    return new h_(paramk);
  }
  
  public static Comparator c(k paramk)
  {
    return new d_(paramk);
  }
  
  public static Comparator d(k paramk)
  {
    return new c_(paramk);
  }
  
  public static Comparator e(k paramk)
  {
    return new i_(paramk);
  }
  
  public static Comparator f(k paramk)
  {
    return new g_(paramk);
  }
  
  public static Comparator a()
  {
    new f_()
    {
      public int compare(Object paramAnonymousObject1, Object paramAnonymousObject2)
      {
        return ((Comparable)paramAnonymousObject1).compareTo(paramAnonymousObject2);
      }
    };
  }
  
  public static Comparator g(k paramk)
  {
    return new e_(paramk);
  }
  
  public static int a(int paramInt1, int paramInt2)
  {
    boolean bool = p.b;
    if (!bool)
    {
      if (paramInt1 < paramInt2) {
        return -1;
      }
      if (bool) {}
    }
    else if (paramInt1 > paramInt2)
    {
      return 1;
    }
    return 0;
  }
  
  public static int a(long paramLong1, long paramLong2)
  {
    boolean bool = p.b;
    if (!bool) {
      if (paramLong1 < paramLong2) {
        return -1;
      }
    }
    if (!bool) {
      if (paramLong1 > paramLong2) {
        return 1;
      }
    }
    return 0;
  }
  
  public static int a(float paramFloat1, float paramFloat2)
  {
    boolean bool = p.b;
    if (!bool) {
      if (paramFloat1 < paramFloat2) {
        return -1;
      }
    }
    if (!bool) {
      if (paramFloat1 > paramFloat2) {
        return 1;
      }
    }
    return 0;
  }
  
  public static int a(double paramDouble1, double paramDouble2)
  {
    boolean bool = p.b;
    if (!bool) {
      if (paramDouble1 < paramDouble2) {
        return -1;
      }
    }
    if (!bool) {
      if (paramDouble1 > paramDouble2) {
        return 1;
      }
    }
    return 0;
  }
  
  public static void a(List paramList, Comparator paramComparator)
  {
    boolean bool = p.b;
    if (!bool) {
      if (paramList.size() < 2) {
        return;
      }
    }
    if (!bool)
    {
      if (!(paramComparator instanceof j_))
      {
        if (!bool)
        {
          if (paramComparator == null) {
            if (bool) {
              break label71;
            }
          }
        }
        else if (!(paramList.get(0) instanceof j_)) {}
      }
      else
      {
        if (bool) {
          break label72;
        }
        j.a(paramList, paramComparator);
      }
    }
    else if (!p.a) {
      return;
    }
    label71:
    label72:
    Collections.sort(paramList, paramComparator);
  }
  
  public static void a(Object[] paramArrayOfObject, Comparator paramComparator)
  {
    boolean bool = p.b;
    if (!bool) {
      if (paramArrayOfObject.length < 2) {
        return;
      }
    }
    if (!bool)
    {
      if (!(paramComparator instanceof j_))
      {
        if (!bool)
        {
          if (paramComparator == null) {
            if (bool) {
              break label63;
            }
          }
        }
        else if (!(paramArrayOfObject[0] instanceof j_)) {}
      }
      else
      {
        if (bool) {
          break label64;
        }
        j.a(paramArrayOfObject, paramComparator);
      }
    }
    else if (!p.a) {
      return;
    }
    label63:
    label64:
    Arrays.sort(paramArrayOfObject, paramComparator);
  }
  
  public static void a(Object[] paramArrayOfObject, int paramInt1, int paramInt2, Comparator paramComparator)
  {
    boolean bool = p.b;
    if (!bool) {
      if (paramInt1 > paramInt2) {
        throw new IllegalArgumentException("fromIndex(" + paramInt1 + ") > toIndex(" + paramInt2 + ")");
      }
    }
    if (!bool) {
      if (paramInt1 < 0) {
        throw a(paramInt1);
      }
    }
    if (!bool)
    {
      if (paramInt2 > paramArrayOfObject.length) {
        throw a(paramInt2);
      }
      if (bool) {}
    }
    else if (paramInt1 == paramInt2)
    {
      return;
    }
    if (!bool)
    {
      if (!(paramComparator instanceof j_))
      {
        if (!bool)
        {
          if (paramComparator == null) {
            if (bool) {
              break label152;
            }
          }
        }
        else if (!(paramArrayOfObject[paramInt1] instanceof j_)) {}
      }
      else
      {
        if (bool) {
          break label154;
        }
        j.a(paramArrayOfObject, paramInt1, paramInt2, paramComparator);
      }
    }
    else if (!p.a) {
      return;
    }
    label152:
    label154:
    Arrays.sort(paramArrayOfObject, paramInt1, paramInt2, paramComparator);
  }
  
  private static ArrayIndexOutOfBoundsException a(int paramInt)
  {
    return new ArrayIndexOutOfBoundsException("Array index out of range: " + paramInt);
  }
  
  public static abstract interface j_ {}
  
  private static class e_
    implements Comparator, l.j_
  {
    k a;
    
    public e_(k paramk)
    {
      this.a = paramk;
    }
    
    public int compare(Object paramObject1, Object paramObject2)
    {
      Comparable localComparable1 = (Comparable)this.a.get(paramObject1);
      Comparable localComparable2 = (Comparable)this.a.get(paramObject2);
      return localComparable1.compareTo(localComparable2);
    }
  }
  
  private static class i_
    implements Comparator
  {
    k a;
    
    public i_(k paramk)
    {
      this.a = paramk;
    }
    
    public int compare(Object paramObject1, Object paramObject2)
    {
      return l.a(this.a.getInt(paramObject1), this.a.getInt(paramObject2));
    }
  }
  
  private static class g_
    implements Comparator
  {
    k a;
    
    public g_(k paramk)
    {
      this.a = paramk;
    }
    
    public int compare(Object paramObject1, Object paramObject2)
    {
      return l.a(this.a.getDouble(paramObject1), this.a.getDouble(paramObject2));
    }
  }
  
  private static class c_
    implements Comparator
  {
    k a;
    
    public c_(k paramk)
    {
      this.a = paramk;
    }
    
    public int compare(Object paramObject1, Object paramObject2)
    {
      e locale1 = ((d)paramObject1).f();
      e locale2 = ((d)paramObject2).f();
      return l.a(this.a.getDouble(locale1), this.a.getDouble(locale2));
    }
  }
  
  private static class d_
    implements Comparator
  {
    k a;
    
    public d_(k paramk)
    {
      this.a = paramk;
    }
    
    public int compare(Object paramObject1, Object paramObject2)
    {
      e locale1 = ((d)paramObject1).e();
      e locale2 = ((d)paramObject2).e();
      return l.a(this.a.getDouble(locale1), this.a.getDouble(locale2));
    }
  }
  
  private static class h_
    implements Comparator
  {
    k a;
    
    public h_(k paramk)
    {
      this.a = paramk;
    }
    
    public int compare(Object paramObject1, Object paramObject2)
    {
      e locale1 = ((d)paramObject1).f();
      e locale2 = ((d)paramObject2).f();
      return l.a(this.a.getInt(locale1), this.a.getInt(locale2));
    }
  }
  
  private static class b_
    implements Comparator
  {
    k a;
    
    public b_(k paramk)
    {
      this.a = paramk;
    }
    
    public int compare(Object paramObject1, Object paramObject2)
    {
      e locale1 = ((d)paramObject1).e();
      e locale2 = ((d)paramObject2).e();
      return l.a(this.a.getInt(locale1), this.a.getInt(locale2));
    }
  }
  
  private static abstract interface f_
    extends Comparator, l.j_
  {}
}



/* Location:           E:\idea\

 * Qualified Name:     a.i.l

 * JD-Core Version:    0.7.0.1

 */